/**
 * 网络请求工具类
 * 基于uni.request API封装
 */

import { log } from "console";

// 默认配置
const baseConfig = {
  baseUrl: 'https://zhuliyouxuan.cn', // 基础URL，根据实际环境配置
  // baseUrl: 'http://43.138.44.15:8283', // 基础URL，根据实际环境配置
  timeout: 10000, // 超时时间，单位ms
  header: {
    'content-type': 'application/json'
  }
}

// 请求拦截器
const requestInterceptors = [
  // 添加token到请求头
  (config) => {
    const token = uni.getStorageSync('token');
    if (token) {
      config.header['Authorization'] = `Bearer ${token}`;
    }
    return config;
  }
]

// 响应拦截器
const responseInterceptors = [
  // 处理响应数据
  (response) => {
    const { data } = response;
    console.log(data);
    // 如果返回的code不是成功，抛出错误
    if (data.code !== '00000') {
      // token过期或无效
      if (data.code === '4001' || data.code === '4002') {
        // 清除本地存储的token
        uni.removeStorageSync('token');


      }
      return Promise.reject(data);
    }
    return data;
  }
]

/**
 * 添加请求拦截器
 * @param {Function} interceptor - 拦截器函数
 */
const addRequestInterceptor = (interceptor) => {
  requestInterceptors.push(interceptor)
}

/**
 * 添加响应拦截器
 * @param {Function} interceptor - 拦截器函数
 */
const addResponseInterceptor = (interceptor) => {
  responseInterceptors.push(interceptor)
}

/**
 * 执行请求拦截器
 * @param {Object} config - 请求配置
 * @returns {Object} - 处理后的请求配置
 */
const processRequestInterceptors = (config) => {
  let processedConfig = { ...config }
  
  requestInterceptors.forEach(interceptor => {
    processedConfig = interceptor(processedConfig) || processedConfig
  })
  
  return processedConfig
}

/**
 * 执行响应拦截器
 * @param {Object} response - 响应结果
 * @returns {Object} - 处理后的响应结果
 */
const processResponseInterceptors = (response) => {
  let processedResponse = { ...response }
  
  responseInterceptors.forEach(interceptor => {
    processedResponse = interceptor(processedResponse) || processedResponse
  })
  
  return processedResponse
}

/**
 * 发起网络请求
 * @param {Object} options - 请求配置
 * @returns {Promise} - 返回Promise对象
 */
const request = (options) => {
  // 合并默认配置和自定义配置
  const config = {
    ...baseConfig,
    ...options,
    header: { ...baseConfig.header, ...options.header }
  }
  
  // 处理URL
  if (!config.url.startsWith('http')) {
    config.url = `${config.baseUrl}${config.url}`
  }

  // 处理 GET 请求参数
  if (config.method === 'GET' && (config.data || config.params)) {
    const queryParams = config.params || config.data;
    const queryString = Object.keys(queryParams)
      .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(queryParams[key])}`)
      .join('&');
    config.url = `${config.url}${config.url.includes('?') ? '&' : '?'}${queryString}`;
    delete config.data;
    delete config.params;
  }
  
  // 执行请求拦截器
  const processedConfig = processRequestInterceptors(config)
  
  // 发起请求
  return new Promise((resolve, reject) => {
    uni.request({
      ...processedConfig,
      success: (res) => {
        // 执行响应拦截器
        const processedRes = processResponseInterceptors(res)
        console.log(processedRes, 'processedRes');
        
        // 根据状态码判断请求是否成功
        if (processedRes.code === '00000') {
          resolve(processedRes)
        } else {
          reject({
            statusCode: processedRes.code,
            errMsg: processedRes.msg || '请求失败',
            data: processedRes.data
          })
        }
      },
      fail: (err) => {
        reject({
          statusCode: -1,
          errMsg: err.msg || '网络异常',
          error: err
        })
      }
    })
  })
}

/**
 * GET请求
 * @param {String} url - 请求地址
 * @param {Object} data - 请求参数
 * @param {Object} options - 其他配置
 * @returns {Promise} - 返回Promise对象
 */
const get = (url, data = {}, options = {}) => {
  return request({
    url,
    data,
    method: 'GET',
    ...options
  })
}

/**
 * POST请求
 * @param {String} url - 请求地址
 * @param {Object} data - 请求参数
 * @param {Object} options - 其他配置
 * @returns {Promise} - 返回Promise对象
 */
const post = (url, data = {}, options = {}) => {
  return request({
    url,
    data,
    method: 'POST',
    ...options
  })
}

/**
 * PUT请求
 * @param {String} url - 请求地址
 * @param {Object} data - 请求参数
 * @param {Object} options - 其他配置
 * @returns {Promise} - 返回Promise对象
 */
const put = (url, data = {}, options = {}) => {
  return request({
    url,
    data,
    method: 'PUT',
    ...options
  })
}

/**
 * DELETE请求
 * @param {String} url - 请求地址
 * @param {Object} data - 请求参数
 * @param {Object} options - 其他配置
 * @returns {Promise} - 返回Promise对象
 */
const del = (url, data = {}, options = {}) => {
  return request({
    url,
    data,
    method: 'DELETE',
    ...options
  })
}

/**
 * 设置全局配置
 * @param {Object} config - 全局配置
 */
const setConfig = (config = {}) => {
  Object.keys(config).forEach(key => {
    if (key in baseConfig) {
      if (typeof baseConfig[key] === 'object') {
        baseConfig[key] = { ...baseConfig[key], ...config[key] }
      } else {
        baseConfig[key] = config[key]
      }
    }
  })
}

export default {
  request,
  get,
  post,
  put,
  del,
  setConfig,
  addRequestInterceptor,
  addResponseInterceptor
}